// 前端交互接口处理模块
use blake3;
use chrono::Utc;
use parking_lot::Mutex;
// serde相关导入可以根据需要添加
use reqwest;
use std::path::PathBuf;
use tauri::ipc::Invoke;
use tauri::Wry;
use uuid::Uuid;

// 导入必要的数据结构
use crate::app_state::AppState;

// 静态资源代理函数 - 支持本地文件和HTTP URL
#[tauri::command]
async fn get_image_data(image_path: String) -> Result<Vec<u8>, String> {
    // 检查是否是HTTP URL
    if image_path.starts_with("http://") || image_path.starts_with("https://") {
        // HTTP URL处理逻辑
        match reqwest::get(&image_path).await {
            Ok(response) => {
                if response.status().is_success() {
                    match response.bytes().await {
                        Ok(bytes) => Ok(bytes.to_vec()),
                        Err(e) => Err(format!("Failed to read response body: {}", e)),
                    }
                } else {
                    Err(format!("HTTP request failed with status: {}", response.status()))
                }
            },
            Err(e) => Err(format!("Failed to send HTTP request: {}", e)),
        }
    } else {
        // 原有本地文件处理逻辑
        // 获取uploads目录
        let uploads_dir = match std::env::var("UPLOADS_DIR") {
            Ok(dir) => dir,
            Err(_) => return Err("Uploads directory not configured".to_string()),
        };
        
        // 构建完整的文件路径
        // 注意：这里移除路径开头的"uploads/"部分
        let clean_path = image_path.trim_start_matches("uploads/");
        let file_path = PathBuf::from(uploads_dir).join(clean_path);
        
        // 检查文件是否存在
        if !file_path.exists() {
            return Err(format!("File not found: {}", image_path));
        }
        
        // 读取文件内容
        match std::fs::read(file_path) {
            Ok(data) => Ok(data),
            Err(e) => Err(format!("Failed to read file: {}", e)),
        }
    }
}

// 获取所有事件
#[tauri::command]
fn get_all_events(state: tauri::State<Mutex<AppState>>, user_id: Option<String>) -> Vec<crate::Event> {
    let state = state.inner().lock();
    // 如果没有提供用户ID，使用默认用户
    let user_id = user_id.unwrap_or_else(|| "default_user".to_string());
    state.get_all_events(&user_id)
}

// 保存新事件
#[tauri::command]
fn save_event(state: tauri::State<Mutex<AppState>>, mut event: crate::Event) -> bool {
    let mut state = state.inner().lock();
    
    // 确保事件有用户ID，如果没有则使用默认用户
    if event.user_id.is_empty() {
        event.user_id = "default_user".to_string();
    }
    
    // 如果事件没有ID，则生成一个新的
    if event.id.is_empty() {
        event.id = Uuid::new_v4().to_string();
    }
    
    // 确保事件有创建时间
    if event.created_at.timestamp() == 0 {
        event.created_at = Utc::now();
    }
    
    state.save_event(event);
    true
}

// 更新事件
#[tauri::command]
fn update_event(state: tauri::State<Mutex<AppState>>, event: crate::Event) -> bool {
    let mut state = state.inner().lock();
    state.save_event(event);
    true
}

// 删除事件
#[tauri::command]
fn delete_event(state: tauri::State<Mutex<AppState>>, event_id: String, user_id: Option<String>) -> bool {
    let mut state = state.inner().lock();
    // 如果没有提供用户ID，使用默认用户
    let user_id = user_id.unwrap_or_else(|| "default_user".to_string());
    state.delete_event(&event_id, &user_id)
}

// 获取用户设置
#[tauri::command]
fn get_user_setting(state: tauri::State<Mutex<AppState>>, key: String, default_value: String, user_id: Option<String>) -> String {
    let mut state = state.inner().lock();
    // 如果没有提供用户ID，使用默认用户
    let user_id = user_id.unwrap_or_else(|| "default_user".to_string());
    state.get_or_create_user_setting(&user_id, &key, &default_value)
}

// 更新用户设置
#[tauri::command]
fn update_user_setting(state: tauri::State<Mutex<AppState>>, key: String, value: String, user_id: Option<String>) -> bool {
    let mut state = state.inner().lock();
    // 如果没有提供用户ID，使用默认用户
    let user_id = user_id.unwrap_or_else(|| "default_user".to_string());
    state.update_user_setting(&user_id, &key, &value);
    true
}

// 根据ID获取单个事件
#[tauri::command]
fn get_event_by_id(state: tauri::State<Mutex<AppState>>, event_id: String, user_id: Option<String>) -> Option<crate::Event> {
    let state = state.inner().lock();
    // 如果没有提供用户ID，使用默认用户
    let user_id = user_id.unwrap_or_else(|| "default_user".to_string());
    state.get_event_by_id(&event_id, &user_id)
}

// 上传文件
#[tauri::command]
fn upload_file(state: tauri::State<Mutex<AppState>>, file_data: Vec<u8>, filename: String, user_id: Option<String>) -> Result<serde_json::Value, String> {
    // 获取用户ID，如果没有提供则使用默认用户
    let user_id = user_id.unwrap_or_else(|| "default_user".to_string());
    
    // 计算文件内容的哈希值，用于检测重复文件
    let file_hash = blake3::hash(&file_data);
    let hash_hex = format!("{}", file_hash);
    
    // 首先查询数据库中是否存在相同哈希的文件，避免扫描目录
    {
        let state_guard = state.inner().lock();
        if let Some(existing_file_url) = state_guard.get_file_by_hash(&user_id, &hash_hex) {
            // 返回JSON对象格式
            let mut result = serde_json::Map::new();
            result.insert("url".to_string(), serde_json::Value::String(existing_file_url));
            return Ok(serde_json::Value::Object(result));
        }
    }
    
    // 获取uploads目录
    let uploads_dir = match std::env::var("UPLOADS_DIR") {
        Ok(dir) => dir,
        Err(_) => return Err("Uploads directory not configured".to_string()),
    };
    
    // 为每个用户创建单独的目录
    let mut user_dir = PathBuf::from(uploads_dir);
    user_dir.push(&user_id);
    
    // 确保用户目录存在
    if let Err(e) = std::fs::create_dir_all(&user_dir) {
        return Err(format!("Failed to create user directory: {}", e));
    }
    
    // 生成唯一的文件名，避免覆盖
      let file_extension = match filename.rsplit_once('.') {
        Some((_, ext)) => format!(".{}", ext),
      None => ".".to_string(),
  };
  // 使用哈希值的前16个字符作为文件名的一部分，便于识别
  let short_hash = &hash_hex[0..16];
  let unique_filename = format!("{}_{}{}", short_hash, Uuid::new_v4(), file_extension);
    
    // 构建完整的文件路径
    let mut file_path = user_dir.clone();
    file_path.push(unique_filename.clone());
    
    // 保存文件
    if let Err(e) = std::fs::write(&file_path, &file_data) {
        return Err(format!("Failed to save file: {}", e));
    }
    
    // 构建相对路径URL，用于后续通过静态资源代理访问
    let file_url = format!("uploads/{}/{}", user_id, unique_filename);
    
    // 保存文件记录到数据库
    {
        let mut state_guard = state.inner().lock();
        state_guard.save_file_record(&user_id, &file_url, &hash_hex, &filename, file_data.len() as u64);
    }
    
    // 返回JSON对象格式
    let mut result = serde_json::Map::new();
    result.insert("url".to_string(), serde_json::Value::String(file_url));
    Ok(serde_json::Value::Object(result))
}

// 保存用户设置到数据库
#[derive(serde::Deserialize)]
struct SaveUserSettingsParams {
    #[serde(alias = "userId")]
    user_id: String,
    settings: serde_json::Value,
}

#[tauri::command]
async fn save_user_settings(params: SaveUserSettingsParams, state: tauri::State<'_, Mutex<AppState>>) -> Result<(), String> {
    let user_id = &params.user_id;
    let settings = &params.settings;
    
    println!("保存用户设置到数据库: user_id = {}, settings = {:?}", user_id, settings);
    
    // 从JSON对象中提取设置并保存到数据库
    if let Some(settings_obj) = settings.as_object() {
        let mut state = state.inner().lock();
        
        // 保存每个设置项到数据库
        for (key, value) in settings_obj {
            // 将value转换为字符串
            let value_str = match value {
                serde_json::Value::String(s) => s.clone(),
                _ => value.to_string()
            };
            
            state.update_user_setting(user_id, key, &value_str);
        }
        
        println!("用户设置已成功保存到数据库");
        return Ok(());
    }
    
    Err("settings必须是对象类型".to_string())
}

// 从数据库获取用户设置
#[tauri::command]
async fn get_user_settings(user_id: Option<String>, state: tauri::State<'_, Mutex<AppState>>) -> Result<serde_json::Value, String> {
    // 如果没有提供用户ID，使用默认用户
    let user_id = user_id.unwrap_or_else(|| "default_user".to_string());

    
    let state = state.inner().lock();
    
    // 从数据库查询所有用户设置
    let mut stmt = match state.db.prepare(
        "SELECT setting_key, setting_value FROM t_user_setting WHERE user_id = ?"
    ) {
        Ok(stmt) => stmt,
        Err(e) => return Err(format!("无法准备查询: {}", e))
    };
    
    // 使用query而不是query_map来避免类型推断问题
    let mut rows = match stmt.query([&user_id]) {
        Ok(rows) => rows,
        Err(e) => return Err(format!("无法执行查询: {}", e))
    };
    
    // 构建设置对象
    let mut settings_map = serde_json::Map::new();
    
    // 遍历所有行
    while let Some(row) = rows.next().unwrap_or_else(|e| {
        println!("读取行失败: {}", e);
        None
    }) {
        // 明确指定类型为String
        match (row.get::<_, String>(0), row.get::<_, String>(1)) {
            (Ok(key), Ok(value)) => {
                // 尝试将值解析为JSON，如果失败则作为字符串处理
                let json_value = match serde_json::from_str(&value) {
                    Ok(val) => val,
                    Err(_) => serde_json::Value::String(value)
                };
                settings_map.insert(key, json_value);
            },
            _ => println!("无法读取设置项的key或value")
        }
    }
    
    Ok(serde_json::Value::Object(settings_map))
}

// 更新用户信息（包含手机号）
#[tauri::command]
pub fn update_user_info(state: tauri::State<'_, Mutex<AppState>>, username: String, avatar: Option<String>, phone: Option<String>) -> Result<bool, String> {
    let mut state = state.inner().lock();
    
    let user_id = "default_user"; // 默认用户ID
    
    // 调用AppState中的方法更新用户信息
    state.update_user_info(user_id, &username, avatar.as_deref(), phone.as_deref());
    
    Ok(true)
}

// 获取用户信息
#[tauri::command]
pub fn get_user_info(state: tauri::State<'_, Mutex<AppState>>) -> Result<Option<serde_json::Value>, String> {
    let state = state.inner().lock();
    
    let user_id = "default_user"; // 默认用户ID
    
    // 获取用户信息
    match state.get_user_info(user_id) {
        Some(user) => {
            // 将用户信息转换为JSON
            let user_json = serde_json::to_value(user).map_err(|e| e.to_string())?;
            Ok(Some(user_json))
        },
        None => Ok(None)
    }
}

// 注册所有前端交互接口
pub fn register_handlers() -> impl Fn(Invoke<Wry>) -> bool {
    tauri::generate_handler![
        get_image_data,
        get_all_events,
        save_event,
        update_event,
        delete_event,
        get_event_by_id,
        get_user_setting,
        update_user_setting,
        upload_file,
        save_user_settings,
        get_user_settings,
        update_user_info,
        get_user_info
    ]
}